// typescript 中定义类 cx  》》》》》》》》》》》》》》》》》》》》》》
// class Person {
//   name: string;
//   constructor(n: string) {
//     this.name = n;
//   }

//   // run() {
//   //   console.log(this.name + '========');
//   // }

//   getName(): string {
//     // 获取值
//     return this.name;
//   }

//   setName(name: string): void {
//     //设置值
//     this.name = name;
//   }
// }

// let p = new Person('jiang');

// console.log(p.getName());

// p.setName('peng');
// console.log(p.getName());

// ts 中的继承  extends super 实现继承 》》》》》》》》》》》》》》》》》》》》》》》
// class Person {
//   name: string;
//   constructor(n: string) {
//     this.name = n;
//   }

//   getName(): string {
//     // 获取值
//     return this.name;
//   }

//   setName(name: string): void {
//     //设置值
//     this.name = name;
//   }
// }

// class Son extends Person {
//   constructor(name: string) {
//     super(name);
//   }
// }

// const son = new Son('lisi');

// console.log(son.getName());

// 类里的修饰符  typescript

/*  》》》》》》》》》》》》》》》》》》》》》》
  public：公有         在类里面，子类，类外面都可以使用
  protected：保护类型  在类里面，子类里面可以访问，在类外面没法是访问
  private ：私有属性   在类里面可以访问，子类，类外面都无法访问
*/

// class Person {
//   protected name: string;
//   private nextName: string;
//   constructor(n: string, next?: any) {
//     this.name = n;
//     this.nextName = next;
//   }

//   getName() {
//     return this.name;
//   }

//   getNext() {
//     return this.nextName;
//   }
// }

// class Son extends Person {
//   constructor(name: string, next: any) {
//     super(name, next);
//   }

//   work(): string {
//     return this.name;
//   }

//   getPerson() {
//     return this.nextName;
//   }
// }

// const son = new Son('zhong', 'jiang');

// console.log(son.getPerson());

//》》》》》》》》》》》》》》》》》》》》》》 静态属性  静态方法 static

// class Person {
//   public name: string;
//   // 静态属性
//   static age: number = 10;
//   constructor(n: string) {
//     this.name = n;
//   }

//   work() {
//     return this.name;
//   }

//   // 静态方法  只能调用静态属性
//   static seeAge(): number {
//     return this.age;
//   }

//   static myLog(_key: any): void {
//     console.log(_key, '------');
//   }
// }

// // const p = new Person('jiang');
// // console.log(p.work());
// Person.myLog(11111);

// 多态  父亲定义一个方法不去实现，让继承他的子类去实现  每一个子类2有不同的表现 》》》》》》》》》》》》》》》》
// 多态属于继承

// class Animate {
//   public name: string;
//   constructor(n: string) {
//     this.name = n;
//   }

//   public eat() {
//     console.log('我是吃东西的方法');
//   }
// }

// class Dog extends Animate {
//   constructor(name: string) {
//     super(name);
//   }

//   eat() {
//     return this.name + '吃骨头';
//   }
// }

// const dog = new Dog('dog');
// console.log(dog.eat());

// class Cat extends Animate {
//   constructor(name: string) {
//     super(name);
//   }

//   eat() {
//     return this.name + '吃鱼';
//   }
// }
// const cat = new Cat('cat');
// console.log(cat.eat());

// typescript 中抽象类： 他是提供其他类继承的基类，不能直接被实例化

// 用abstract 关键字定义抽象类和抽象方法，抽象类中的抽象方法不包含具体实现并且必须在派生类中实现

// abstract 抽象方法只能放在抽象类里面

// 抽象类和抽象方法用来定义标准，  标准：Animal 这个类要求它的子类必须包含eat 方法

// abstract class Animal {
//   public name: string;
//   constructor(na: string) {
//     this.name = na;
//   }
//   abstract eat(): void;
// }

// // const An = new Animal('12');   // 无法创建抽象类的实例  错误写法

// class Dog extends Animal {
//   constructor(name: string) {
//     super(name);
//   }

//   eat(): void {
//     console.log(this.name + '吃大便');
//   }
// }

// const dog = new Dog('dog');

// dog.eat();

// class Cat extends Animal {
//   constructor(name: string) {
//     super(name);
//   }
//   eat() {} // 抽象方法在子类里必须实现
//   run(): string {
//     return this.name + ' run';
//   }
// }

// const cat = new Cat('CAT');

// console.log(cat.run());
